package com.clarence.dada.modular.system.role.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.lang.TypeReference;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.clarence.dada.core.auth.context.LoginContext;
import com.clarence.dada.core.base.PageResult;
import com.clarence.dada.core.redis.RedisOperatorApi;
import com.clarence.dada.core.enums.ErrorEnum;
import com.clarence.dada.core.enums.StatusEnum;
import com.clarence.dada.core.enums.YesOrNotEnum;
import com.clarence.dada.core.exception.BusException;
import com.clarence.dada.core.exception.ServiceException;
import com.clarence.dada.core.factory.PageFactory;
import com.clarence.dada.core.factory.PageResultFactory;
import com.clarence.dada.modular.system.menu.service.SysMenuService;
import com.clarence.dada.modular.system.role.entity.SysRoleEntity;
import com.clarence.dada.modular.system.role.entity.SysRoleMenuButtonEntity;
import com.clarence.dada.modular.system.role.entity.SysRoleMenuEntity;
import com.clarence.dada.modular.system.role.entity.req.SysRoleReq;
import com.clarence.dada.modular.system.role.entity.resp.SysRoleDropDownResp;
import com.clarence.dada.modular.system.role.entity.resp.SysRoleResp;
import com.clarence.dada.modular.system.role.mapper.SysRoleMapper;
import com.clarence.dada.modular.system.role.service.SysRoleMenuButtonService;
import com.clarence.dada.modular.system.role.service.SysRoleMenuService;
import com.clarence.dada.modular.system.role.service.SysRoleResourceService;
import com.clarence.dada.modular.system.role.service.SysRoleService;
import jakarta.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;


/**
 * 系统角色service接口实现类
 *
 * @author GD
 * @since 2020/11/5 上午11:33
 */
@Service
public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRoleEntity> implements SysRoleService {

    @Resource
    private SysRoleMapper sysRoleMapper;

    //    @Resource
//    private UserServiceApi userServiceApi;

    @Resource
    private SysRoleResourceService sysRoleResourceService;
//
//    @Resource
//    private SysRoleDataScopeService sysRoleDataScopeService;
//
    @Resource
    private SysRoleMenuService roleMenuService;

    @Resource
    private SysRoleMenuButtonService sysRoleMenuButtonService;
//
//    @Resource
//    private RedisOperatorApi<SysRole> roleInfoCacheApi;

    @Resource(name = "roleResourceCacheApi")
    private RedisOperatorApi<List<String>> roleResourceCacheApi;
//
//    @Resource(name = "roleDataScopeCacheApi")
//    private RedisOperatorApi<List<Long>> roleDataScopeCacheApi;
//
//    @Resource
//    private ResourceServiceApi resourceServiceApi;

    @Override
    public void roleAdd(SysRoleReq req) {
        SysRoleEntity sysRoleEntity = Convert.convert(SysRoleEntity.class, req);
        sysRoleEntity.setAdminFlag(YesOrNotEnum.N.getCode());
        sysRoleEntity.setStatusFlag(StatusEnum.ENABLE.getCode());
        sysRoleEntity.setRoleSystemFlag(YesOrNotEnum.N.getCode());
        this.save(sysRoleEntity);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void roleDelete(SysRoleReq req) {

        SysRoleEntity sysRoleEntity = sysRoleMapper.selectById(req.getRoleId());

        // 超级管理员不能删除
        if ("superAdmin".equals(sysRoleEntity.getRoleCode())) {
            throw new ServiceException(ErrorEnum.SYSTEM_ROLE_CANT_DELETE);
        }

        // 级联删除该角色对应的用户-角色表关联信息
//        userServiceApi.deleteUserRoleListByRoleId(sysRoleEntity.getId());
//
//        // 级联删除该角色对应的角色-菜单表关联信息
//        sysRoleResourceService.deleteRoleResourceListByRoleId(sysRoleEntity.getId(), null);

        // 删除角色
        this.removeById(sysRoleEntity.getRoleId());
    }
//
//    @Override
//    public void grantResourceV2GrantAll(SysRoleVo sysRoleVo) {
//
//        // 删除角色绑定的所有资源
//        this.sysRoleResourceService.deleteRoleResourceListByRoleId(sysRoleRequest.getRoleId(), sysRoleRequest.getResourceBizType());
//
//        // 获取是全部选中，还是全部取消，如果是全部取消，则直接返回
//        if (!sysRoleRequest.getTotalSelectFlag()) {
//            return;
//        }
//
//        // 如果是全部选中，则查询一共有多少资源，将角色赋予全部资源
//        ResBizTypeEnum resBizTypeEnum = null;
//        if (ObjectUtil.isNotEmpty(sysRoleRequest.getResourceBizType())) {
//            resBizTypeEnum = ResBizTypeEnum.DEFAULT.parseToEnum(sysRoleRequest.getResourceBizType().toString());
//        }
//        List<SysRoleResourceDTO> totalResourceCode = resourceServiceApi.getTotalResourceCode(resBizTypeEnum);
//        this.sysRoleResourceService.batchSaveResCodes(sysRoleRequest.getRoleId(), totalResourceCode);
//    }
//
//    @Override
//    public SysRoleDto getRoleByCode(String roleCode) {
//        if (roleCode == null) {
//            return null;
//        }
//
//        LambdaQueryWrapper<SysRoleEntity> sysRoleLambdaQueryWrapper = new LambdaQueryWrapper<>();
//        sysRoleLambdaQueryWrapper.eq(SysRoleEntity::getRoleCode, roleCode);
//        sysRoleLambdaQueryWrapper.ne(SysRoleEntity::getDelFlag, YesOrNotEnum.Y.getCode());
//        SysRoleEntity sysRoleEntity = this.getOne(sysRoleLambdaQueryWrapper, false);
//
//        if (sysRoleEntity == null) {
//            return null;
//        }
//
//        SysRoleDto roleResponse = new SysRoleDto();
//        BeanUtil.copyProperties(sysRoleEntity, roleResponse);
//
//        return roleResponse;
//    }

//    @Override
//    public RoleAuthorizeInfoDto getRoleAuthorizeInfo(List<Long> roleIdList) {
//
//        HashSet<String> result = new HashSet<>();
//
//        for (Long roleId : roleIdList) {
//
//            // 从缓存获取所有角色绑定的资源
//            String key = String.valueOf(roleId);
//            List<String> resourceCodesCache = roleResourceCacheApi.get(key);
//            if (ObjectUtil.isNotEmpty(resourceCodesCache)) {
//                result.addAll(resourceCodesCache);
//                continue;
//            }
//
//            // 从数据库查询角色绑定的资源
//            LambdaQueryWrapper<SysRoleResourceEntity> queryWrapper = new LambdaQueryWrapper<>();
//            queryWrapper.select(SysRoleResourceEntity::getResourceCode);
//            queryWrapper.eq(SysRoleResourceEntity::getRoleId, roleId);
//            List<SysRoleResourceEntity> sysRoleResources = sysRoleResourceService.list(queryWrapper);
//            List<String> sysResourceCodes = sysRoleResources.parallelStream().map(SysRoleResourceEntity::getResourceCode).collect(Collectors.toList());
//            if (ObjectUtil.isNotEmpty(sysResourceCodes)) {
//                result.addAll(sysResourceCodes);
//                roleResourceCacheApi.put(key, sysResourceCodes);
//            }
//        }
//
//        // 获取角色的所有菜单
//        LambdaQueryWrapper<SysRoleMenuEntity> wrapper = new LambdaQueryWrapper<>();
//        wrapper.in(SysRoleMenuEntity::getRoleId, roleIdList);
//        wrapper.select(SysRoleMenuEntity::getMenuId);
//        List<SysRoleMenuEntity> list = this.roleMenuService.list(wrapper);
//        List<Long> menuIds = list.stream().map(SysRoleMenuEntity::getMenuId).collect(Collectors.toList());
//
//        // 获取角色绑定的所有按钮
//        LambdaQueryWrapper<SysRoleMenuButtonEntity> wrapper2 = new LambdaQueryWrapper<>();
//        wrapper2.in(SysRoleMenuButtonEntity::getRoleId, roleIdList);
//        wrapper2.select(SysRoleMenuButtonEntity::getButtonId);
//        List<SysRoleMenuButtonEntity> roleMenuButtons = this.sysRoleMenuButtonService.list(wrapper2);
//        List<Long> buttonIds = roleMenuButtons.stream().map(SysRoleMenuButtonEntity::getButtonId).collect(Collectors.toList());
//
//        // 获取菜单和按钮所有绑定的资源
//        ArrayList<Long> businessIds = new ArrayList<>();
//        businessIds.addAll(menuIds);
//        businessIds.addAll(buttonIds);
//
//        // 获取菜单和按钮
//        List<String> menuButtonResources = sysMenuService.getResourceCodesByBusinessId(businessIds);
//        result.addAll(menuButtonResources);
//
//        // 封装返回结果
//        return new RoleAuthorizeInfoDto(menuIds, buttonIds, result);
//    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void roleEdit(SysRoleReq req) {
        SysRoleEntity sysRoleEntity = sysRoleMapper.selectById(req.getRoleId());

        if ("superAdmin".equals(sysRoleEntity.getRoleCode())) {
            throw new BusException(ErrorEnum.SUPER_ADMIN_ROLE_ERROR);
        }
        if (!sysRoleEntity.getRoleCode().equals(req.getRoleCode())) {
            throw new BusException(ErrorEnum.ROLE_CODE_ERROR);
        }

        BeanUtil.copyProperties(req, sysRoleEntity);
        sysRoleEntity.setStatusFlag(null);

        this.updateById(sysRoleEntity);
    }

    @Override
    public SysRoleResp roleDetail(SysRoleReq req) {
        if (ObjectUtil.isEmpty(req.getRoleId())) {
            throw new BusException(ErrorEnum.ERROR_NULL_PARAMS);
        }
        SysRoleEntity sysRoleEntity = sysRoleMapper.selectById(req.getRoleId());
        if (ObjectUtil.isEmpty(sysRoleEntity)) {
            return null;
        }
        return Convert.convert(SysRoleResp.class, sysRoleEntity);
    }

    @Override
    public PageResult<SysRoleResp> rolePage(SysRoleReq req) {
        req.setAdminFlag(YesOrNotEnum.N.getCode());
        LambdaQueryWrapper<SysRoleEntity> wrapper = createWrapper(req);
        Page<SysRoleEntity> page = this.page(PageFactory.defaultPage(), wrapper);
        List<SysRoleResp> respList = Convert.convert(new TypeReference<>() {
        }, page.getRecords());
        return PageResultFactory.result(page, respList);
    }
//
//    @Override
//    public List<SimpleDict> findList(SysRoleRequest sysRoleParam) {
//        List<SimpleDict> dictList = CollectionUtil.newArrayList();
//        LambdaQueryWrapper<SysRole> queryWrapper = new LambdaQueryWrapper<>();
//        if (ObjectUtil.isNotNull(sysRoleParam)) {
//
//            // 根据角色名称或编码模糊查询
//            if (ObjectUtil.isNotEmpty(sysRoleParam.getRoleName())) {
//                queryWrapper.and(i -> i.like(SysRole::getRoleName, sysRoleParam.getRoleName()).or().like(SysRole::getRoleCode, sysRoleParam.getRoleName()));
//            }
//        }
//
//        // 只查询正常状态
//        queryWrapper.eq(SysRole::getStatusFlag, StatusEnum.ENABLE.getCode());
//
//        // 根据排序升序排列，序号越小越在前
//        queryWrapper.orderByAsc(SysRole::getRoleSort);
//        this.list(queryWrapper).forEach(sysRole -> {
//            SimpleDict simpleDict = new SimpleDict();
//            simpleDict.setId(sysRole.getRoleId());
//            simpleDict.setName(sysRole.getRoleName() + SymbolConstant.LEFT_SQUARE_BRACKETS + sysRole.getRoleCode() + SymbolConstant.RIGHT_SQUARE_BRACKETS);
//            dictList.add(simpleDict);
//        });
//        return dictList;
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void grantMenuAndButton(SysRoleRequest sysRoleMenuButtonRequest) {
//
//        // 清除该角色之前的菜单
//        LambdaQueryWrapper<SysRoleMenu> sysRoleMenuLqw = new LambdaQueryWrapper<>();
//        sysRoleMenuLqw.eq(SysRoleMenu::getRoleId, sysRoleMenuButtonRequest.getRoleId());
//        roleMenuService.remove(sysRoleMenuLqw);
//
//        // 清除该角色之前的按钮授权
//        LambdaQueryWrapper<SysRoleMenuButton> menuButtonLqw = new LambdaQueryWrapper<>();
//        menuButtonLqw.eq(SysRoleMenuButton::getRoleId, sysRoleMenuButtonRequest.getRoleId());
//        sysRoleMenuButtonService.remove(menuButtonLqw);
//
//        // 新增菜单
//        List<Long> menuIdList = sysRoleMenuButtonRequest.getGrantMenuIdList();
//        if (ObjectUtil.isNotEmpty(menuIdList)) {
//            List<SysRoleMenu> sysRoleMenus = new ArrayList<>();
//
//            // 角色ID
//            Long roleId = sysRoleMenuButtonRequest.getRoleId();
//
//            // 查询菜单的所有父菜单
//            Set<Long> allParentMenuId = menuServiceApi.getMenuAllParentMenuId(new HashSet<>(menuIdList));
//
//            // 处理所有父菜单
//            for (Long menuId : allParentMenuId) {
//                SysRoleMenu item = new SysRoleMenu();
//                item.setRoleId(roleId);
//                item.setMenuId(menuId);
//                sysRoleMenus.add(item);
//            }
//
//            // 处理菜单本身
//            for (Long menuId : menuIdList) {
//                SysRoleMenu item = new SysRoleMenu();
//                item.setRoleId(roleId);
//                item.setMenuId(menuId);
//                sysRoleMenus.add(item);
//            }
//            roleMenuService.saveBatch(sysRoleMenus);
//        }
//
//        // 新增按钮
//        List<SysRoleMenuButtonRequest> menuButtonList = sysRoleMenuButtonRequest.getGrantMenuButtonIdList();
//        if (ObjectUtil.isNotEmpty(menuButtonList)) {
//            List<SysRoleMenuButton> sysRoleMenuButtons = new ArrayList<>();
//            for (SysRoleMenuButtonRequest menuButton : menuButtonList) {
//                SysRoleMenuButton item = new SysRoleMenuButton();
//                item.setRoleId(sysRoleMenuButtonRequest.getRoleId());
//                item.setButtonId(menuButton.getButtonId());
//                item.setButtonCode(menuButton.getButtonCode());
//                sysRoleMenuButtons.add(item);
//            }
//            sysRoleMenuButtonService.saveBatch(sysRoleMenuButtons);
//        }
//    }
//
//    @Override
//    public void grantMenu(SysRoleRequest sysRoleMenuButtonRequest) {
//
//        // 获取新增还是取消绑定
//        Boolean grantAddMenuFlag = sysRoleMenuButtonRequest.getGrantAddMenuFlag();
//
//        // 如果是新增绑定菜单
//        if (grantAddMenuFlag) {
//            SysRoleMenu item = new SysRoleMenu();
//            item.setRoleId(sysRoleMenuButtonRequest.getRoleId());
//            item.setMenuId(sysRoleMenuButtonRequest.getGrantMenuId());
//            this.roleMenuService.save(item);
//        } else {
//            //如果是解除绑定菜单
//            LambdaUpdateWrapper<SysRoleMenu> wrapper = new LambdaUpdateWrapper<>();
//            wrapper.eq(SysRoleMenu::getRoleId, sysRoleMenuButtonRequest.getRoleId());
//            wrapper.eq(SysRoleMenu::getMenuId, sysRoleMenuButtonRequest.getGrantMenuId());
//            this.roleMenuService.remove(wrapper);
//        }
//    }
//
//    @Override
//    public List<MenuAndButtonTreeResponse> grantButton(SysRoleRequest sysRoleMenuButtonRequest) {
//        // 该模块下角色绑定的按钮全部删除
//        List<Long> modularButtonIds = sysRoleMenuButtonRequest.getModularButtonIds();
//        if (ObjectUtil.isNotEmpty(modularButtonIds)) {
//            LambdaUpdateWrapper<SysRoleMenuButton> wrapper = new LambdaUpdateWrapper<>();
//            wrapper.in(SysRoleMenuButton::getButtonId, modularButtonIds);
//            wrapper.eq(SysRoleMenuButton::getRoleId, sysRoleMenuButtonRequest.getRoleId());
//            this.sysRoleMenuButtonService.remove(wrapper);
//        }
//
//        // 该模块下，勾选的按钮，添加到角色绑定
//        List<Long> selectedButtonIds = sysRoleMenuButtonRequest.getSelectedButtonIds();
//        if (ObjectUtil.isNotEmpty(selectedButtonIds)) {
//            ArrayList<SysRoleMenuButton> sysRoleMenuButtons = new ArrayList<>();
//            for (Long selectButtonId : selectedButtonIds) {
//                SysRoleMenuButton sysRoleMenuButton = new SysRoleMenuButton();
//                sysRoleMenuButton.setRoleId(sysRoleMenuButtonRequest.getRoleId());
//                sysRoleMenuButton.setButtonId(selectButtonId);
//
//                // 通过buttonId获取buttonCode
//                String buttonCode = this.menuServiceApi.getMenuButtonCodeByButtonId(selectButtonId);
//                sysRoleMenuButton.setButtonCode(buttonCode);
//
//                sysRoleMenuButtons.add(sysRoleMenuButton);
//            }
//            this.sysRoleMenuButtonService.saveBatch(sysRoleMenuButtons, sysRoleMenuButtons.size());
//        }
//
//        // 返回角色绑定的按钮列表
//        return this.menuServiceApi.getRoleBindOperateList(sysRoleMenuButtonRequest);
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void grantDataScope(SysRoleVo sysRoleVo) {
//        SysRoleEntity sysRoleEntity = this.querySysRole(sysRoleRequest);
//
//        // 获取当前用户是否是超级管理员
//        boolean superAdmin = LoginContext.me().getSuperAdminFlag();
//
//        // 获取请求参数的数据范围类型
//        Integer dataScopeType = sysRoleRequest.getDataScopeType();
//        DataScopeTypeEnum dataScopeTypeEnum = DataScopeTypeEnum.codeToEnum(dataScopeType);
//
//        // 如果登录用户不是超级管理员，则进行数据权限校验
//        if (!superAdmin) {
//
//            // 只有超级管理员可以授权全部范围
//            if (DataScopeTypeEnum.ALL.equals(dataScopeTypeEnum)) {
//                throw new AuthException(AuthExceptionEnum.ONLY_SUPER_ERROR);
//            }
//
//            // 数据范围类型为自定义，则判断当前用户有没有该公司的权限
//            if (DataScopeTypeEnum.DEFINE.getCode().equals(dataScopeType)) {
//                if (ObjectUtil.isEmpty(sysRoleRequest.getGrantOrgIdList())) {
//                    throw new SystemModularException(SysRoleExceptionEnum.PLEASE_FILL_DATA_SCOPE);
//                }
//                for (Long orgId : sysRoleRequest.getGrantOrgIdList()) {
//                    DataScopeUtil.quickValidateDataScope(orgId);
//                }
//            }
//        }
//
//        sysRole.setDataScopeType(sysRoleRequest.getDataScopeType());
//        this.updateById(sysRole);
//
//        // 绑定角色数据范围关联
//        sysRoleDataScopeService.grantDataScope(sysRoleRequest);
//
//        // 删除角色的数据范围缓存
//        roleDataScopeCacheApi.remove(String.valueOf(sysRoleRequest.getRoleId()));
//    }

    @Override
    public List<SysRoleDropDownResp> roleDropDown() {
        LambdaQueryWrapper<SysRoleEntity> wrapper = new LambdaQueryWrapper<>();

        // 如果当前登录用户不是超级管理员，则查询自己拥有的角色
        if (!LoginContext.me().getSuperAdminFlag()) {

            // 查询自己拥有的
//            List<SimpleRoleInfo> roles = LoginContext.me().getLoginUser().getSimpleRoleInfoList();

            // 取出所有角色id
//            Set<Long> loginUserRoleIds = roles.stream().map(SimpleRoleInfo::getRoleId).collect(Collectors.toSet());
            Set<Long> loginUserRoleIds = new HashSet<>();
            loginUserRoleIds.add(1339550467939639303L);
            loginUserRoleIds.add(1744650979672666113L);

            if (ObjectUtil.isEmpty(loginUserRoleIds)) {
                return Collections.emptyList();
            }
            wrapper.in(SysRoleEntity::getRoleId, loginUserRoleIds);
        }

        // 只查询正常状态
        wrapper.eq(SysRoleEntity::getStatusFlag, StatusEnum.ENABLE.getCode()).eq(SysRoleEntity::getDelFlag, YesOrNotEnum.N.getCode());

        // 只查询非管理员的角色
        wrapper.eq(SysRoleEntity::getAdminFlag, YesOrNotEnum.N.getCode());

        List<SysRoleEntity> list = this.list(wrapper);
        if (CollUtil.isEmpty(list)) {
            return Collections.emptyList();
        }
        return Convert.convert(new TypeReference<>() {
        }, list);
    }

    //
//    @Override
//    public List<Long> getRoleDataScope(SysRoleVo sysRoleVo) {
//        SysRoleEntity sysRoleEntity = this.querySysRole(sysRoleRequest);
//        return sysRoleDataScopeService.getRoleDataScopeIdList(CollectionUtil.newArrayList(sysRole.getRoleId()));
//    }
//
//    @Override
//    public void grantMenusAndButtons(SysRoleVo sysRoleVo) {
//
//        // 授权角色绑定的菜单
//        this.grantRoleMenus(sysRoleRequest);
//
//        // 授权按钮
//        if (ObjectUtil.isNotEmpty(sysRoleRequest.getModularButtonIds())) {
//            this.grantButton(sysRoleRequest);
//        }
//
//    }
//
//    @Override
//    public List<MenuAndButtonTreeResponse> grantMenusAndButtonsAndGetResult(SysRoleVo sysRoleVo) {
//        this.grantMenusAndButtons(sysRoleRequest);
//        return menuServiceApi.getRoleMenuAndButtons(sysRoleRequest);
//    }
//
//    @Override
//    public List<MenuAndButtonTreeResponse> grantRoleMenus(SysRoleVo sysRoleVo) {
//
//        // 获取新增绑定还是取消绑定菜单
//        Boolean selectBindFlag = sysRoleRequest.getSelectBindFlag();
//
//        // 获取角色和绑定菜单
//        Long roleId = sysRoleRequest.getRoleId();
//        List<Long> grantMenuIdList = sysRoleRequest.getGrantMenuIdList();
//
//        // 如果是新增绑定菜单
//        if (selectBindFlag) {
//            // 获取所有菜单的父级节点，把选中状态的菜单的所有父级节点都选择上
//            Set<Long> allParentMenuId = menuServiceApi.getMenuAllParentMenuId(new HashSet<>(grantMenuIdList));
//            grantMenuIdList.addAll(allParentMenuId);
//
//            // 批量保存绑定的菜单集合
//            List<SysRoleMenu> sysRoleMenus = new ArrayList<>();
//            for (Long menuId : grantMenuIdList) {
//                SysRoleMenu item = new SysRoleMenu();
//                item.setRoleId(roleId);
//                item.setMenuId(menuId);
//                sysRoleMenus.add(item);
//            }
//            this.roleMenuService.saveBatch(sysRoleMenus);
//        } else {
//            // 如果是解除绑定菜单
//            LambdaUpdateWrapper<SysRoleMenu> wrapper = new LambdaUpdateWrapper<>();
//            wrapper.eq(SysRoleMenu::getRoleId, roleId);
//            wrapper.in(SysRoleMenu::getMenuId, grantMenuIdList);
//            this.roleMenuService.remove(wrapper);
//        }
//
//        // 获取当前角色分配的菜单权限
//        return menuServiceApi.getRoleBindMenuList(sysRoleRequest);
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class, isolation = Isolation.READ_UNCOMMITTED)
//    public List<MenuAndButtonTreeResponse> grantRoleMenusGrantAll(SysRoleVo sysRoleVo) {
//
//        // 根据参数的前后台类型，获取所有菜单id
//        AntdvFrontTypeEnum antdvFrontTypeEnum = AntdvFrontTypeEnum.parseToEnum(sysRoleRequest.getResourceBizType());
//        List<Long> totalMenuIdList = this.menuServiceApi.getTotalMenuIdList(antdvFrontTypeEnum);
//
//        // 删除角色绑定的所有菜单
//        LambdaUpdateWrapper<SysRoleMenu> wrapper = new LambdaUpdateWrapper<>();
//        wrapper.eq(SysRoleMenu::getRoleId, sysRoleRequest.getRoleId());
//        wrapper.in(SysRoleMenu::getMenuId, totalMenuIdList);
//        this.roleMenuService.remove(wrapper);
//
//        // 获取当前角色分配的菜单权限
//        List<MenuAndButtonTreeResponse> roleBindMenuList = menuServiceApi.getRoleBindMenuList(sysRoleRequest);
//
//        // 如果是取消权限，则直接返回
//        if (!sysRoleRequest.getTotalSelectFlag()) {
//            return roleBindMenuList;
//        }
//
//        // 批量保存绑定的菜单集合
//        List<SysRoleMenu> sysRoleMenus = new ArrayList<>();
//        for (Long menuId : totalMenuIdList) {
//            SysRoleMenu item = new SysRoleMenu();
//            item.setRoleId(sysRoleRequest.getRoleId());
//            item.setMenuId(menuId);
//            sysRoleMenus.add(item);
//        }
//        this.roleMenuService.saveBatch(sysRoleMenus);
//
//        return roleBindMenuList;
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class, isolation = Isolation.READ_UNCOMMITTED)
//    public List<MenuAndButtonTreeResponse> grantButtonGrantAll(SysRoleVo sysRoleVo) {
//
//        // 删除角色绑定的所有按钮权限
//        LambdaUpdateWrapper<SysRoleMenuButton> wrapper = new LambdaUpdateWrapper<>();
//        wrapper.eq(SysRoleMenuButton::getRoleId, sysRoleRequest.getRoleId());
//        this.sysRoleMenuButtonService.remove(wrapper);
//
//        // 获取当前角色分配的操作权限
//        List<MenuAndButtonTreeResponse> roleBindOperateList = menuServiceApi.getRoleBindOperateList(sysRoleRequest);
//
//        // 如果是取消权限，则直接返回
//        if (!sysRoleRequest.getTotalSelectFlag()) {
//            return roleBindOperateList;
//        }
//
//        // 获取所有前台按钮集合
//        AntdvFrontTypeEnum antdvFrontTypeEnum = AntdvFrontTypeEnum.parseToEnum(sysRoleRequest.getResourceBizType());
//        List<SysMenuButtonDTO> totalButtonIds = this.menuServiceApi.getTotalMenuButtonIdList(antdvFrontTypeEnum);
//
//        // 批量保存绑定的按钮集合
//        List<SysRoleMenuButton> sysRoleMenuButtons = new ArrayList<>();
//        for (SysMenuButtonDTO buttonDTO : totalButtonIds) {
//            SysRoleMenuButton item = new SysRoleMenuButton();
//            item.setRoleId(sysRoleRequest.getRoleId());
//            item.setButtonId(buttonDTO.getButtonId());
//            item.setButtonCode(buttonDTO.getButtonCode());
//            sysRoleMenuButtons.add(item);
//        }
//        this.sysRoleMenuButtonService.batchSaveRoleMenuButton(sysRoleMenuButtons);
//
//        return roleBindOperateList;
//    }

    @Override
    public List<SysRoleResp> getRolesByIds(List<Long> roleIds) {
        ArrayList<SysRoleResp> sysRoleRespList = new ArrayList<>();
        for (Long roleId : roleIds) {
            SysRoleReq req = new SysRoleReq();
            req.setRoleId(roleId);
            SysRoleResp detail = this.roleDetail(req);
            sysRoleRespList.add(detail);
        }
        return sysRoleRespList;
    }

//    @Override
//    public List<Long> getRoleDataScopes(List<Long> roleIds) {
//
//        ArrayList<Long> result = new ArrayList<>();
//
//        if (ObjectUtil.isEmpty(roleIds)) {
//            return result;
//        }
//
//        for (Long roleId : roleIds) {
//            // 从缓存获取数据范围
//            String key = String.valueOf(roleId);
//            List<Long> scopes = roleDataScopeCacheApi.get(key);
//            if (scopes != null) {
//                result.addAll(scopes);
//            }
//
//            // 从数据库查询数据范围
//            LambdaQueryWrapper<SysRoleDataScope> queryWrapper = new LambdaQueryWrapper<>();
//            queryWrapper.eq(SysRoleDataScope::getRoleId, roleId);
//            List<SysRoleDataScope> list = this.sysRoleDataScopeService.list(queryWrapper);
//            if (!list.isEmpty()) {
//                List<Long> realScopes = list.stream().map(SysRoleDataScope::getOrganizationId).collect(Collectors.toList());
//                result.addAll(realScopes);
//
//                // 添加结果到缓存中
//                roleDataScopeCacheApi.put(key, realScopes);
//            }
//        }
//
//        return result;
//    }
//
    @Override
    public List<Long> getMenuIdsByRoleIds(List<Long> roleIds) {
        if (roleIds == null || roleIds.isEmpty()) {
            return Collections.emptyList();
        }
        LambdaQueryWrapper<SysRoleMenuEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(SysRoleMenuEntity::getRoleId, roleIds)
                .select(SysRoleMenuEntity::getMenuId);

        List<SysRoleMenuEntity> roleMenus = this.roleMenuService.list(queryWrapper);
        if (roleMenus == null || roleMenus.isEmpty()) {
            return Collections.emptyList();
        }
        return roleMenus.stream().map(SysRoleMenuEntity::getMenuId).toList();
    }

//    @Override
//    public Set<String> getRoleResourceCodeList(List<Long> roleIdList) {
//        RoleAuthorizeInfoDto roleAuthorizeInfo = this.getRoleAuthorizeInfo(roleIdList);
//        return roleAuthorizeInfo.getResourceCodeList();
//    }
//
//    @Override
//    public List<SysRoleResourceDTO> getRoleResourceList(List<Long> roleIdList) {
//        LambdaQueryWrapper<SysRoleResource> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.in(SysRoleResource::getRoleId, roleIdList);
//        List<SysRoleResource> sysRoleResources = sysRoleResourceService.list(queryWrapper);
//        return sysRoleResources.parallelStream().map(item -> BeanUtil.copyProperties(item, SysRoleResourceDTO.class)).collect(Collectors.toList());
//    }

    @Override
    public Set<String> getRoleButtonCodes(List<Long> roleIdList) {
        LambdaQueryWrapper<SysRoleMenuButtonEntity> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(SysRoleMenuButtonEntity::getRoleId, roleIdList);
        queryWrapper.select(SysRoleMenuButtonEntity::getButtonCode);
        List<SysRoleMenuButtonEntity> list = sysRoleMenuButtonService.list(queryWrapper);
        return list.stream().map(SysRoleMenuButtonEntity::getButtonCode).collect(Collectors.toSet());
    }
//
//    @Override
//    public List<SysRoleMenuDTO> getRoleMenuList(List<Long> roleIdList) {
//        LambdaQueryWrapper<SysRoleMenu> sysRoleMenuLambdaQueryWrapper = new LambdaQueryWrapper<>();
//        sysRoleMenuLambdaQueryWrapper.in(SysRoleMenu::getRoleId, roleIdList);
//        List<SysRoleMenu> roleMenus = roleMenuService.list(sysRoleMenuLambdaQueryWrapper);
//        return roleMenus.parallelStream().map(item -> BeanUtil.copyProperties(item, SysRoleMenuDTO.class)).collect(Collectors.toList());
//    }
//
//    @Override
//    public List<SysRoleMenuButtonDTO> getRoleMenuButtonList(List<Long> roleIdList) {
//        LambdaQueryWrapper<SysRoleMenuButton> sysRoleMenuButtonLambdaQueryWrapper = new LambdaQueryWrapper<>();
//        sysRoleMenuButtonLambdaQueryWrapper.in(SysRoleMenuButton::getRoleId, roleIdList);
//        List<SysRoleMenuButton> sysRoleMenuButtons = sysRoleMenuButtonService.list(sysRoleMenuButtonLambdaQueryWrapper);
//        return sysRoleMenuButtons.parallelStream().map(item -> BeanUtil.copyProperties(item, SysRoleMenuButtonDTO.class)).collect(Collectors.toList());
//    }
//
//    @Override
//    public List<SysRoleDto> getRoleSelectList(SysRoleReq sysRoleReq) {
//
//        LambdaQueryWrapper<SysRole> wrapper = this.createWrapper(sysRoleReq);
//        List<SysRole> list = this.list(wrapper);
//
//        ArrayList<SysRoleDto> sysRoleDTOS = new ArrayList<>();
//        for (SysRole sysRole : list) {
//            SysRoleDto sysRoleDTO = new SysRoleDto();
//            BeanUtil.copyProperties(sysRole, sysRoleDTO);
//            sysRoleDTOS.add(sysRoleDTO);
//        }
//
//        return sysRoleDTOS;
//    }
//
//    @Override
//    public void addAdminRole(SysRoleVo sysRoleVo) {
//        SysRoleEntity sysRoleEntity = new SysRoleEntity();
//
//        sysRole.setRoleId(sysRoleRequest.getRoleId());
//        sysRole.setRoleName(sysRoleRequest.getRoleName());
//        sysRole.setRoleCode(sysRoleRequest.getRoleCode());
//
//        sysRole.setRoleSort(new BigDecimal(9999));
//        sysRole.setDataScopeType(DataScopeTypeEnum.ALL.getCode());
//        sysRole.setStatusFlag(StatusEnum.ENABLE.getCode());
//        sysRole.setAdminFlag(YesOrNotEnum.Y.getCode());
//        sysRole.setRoleSystemFlag(YesOrNotEnum.Y.getCode());
//        sysRole.setDelFlag(YesOrNotEnum.N.getCode());
//
//        this.save(sysRole);
//    }
//
//    /**
//     * 获取系统角色
//     *
//     * @param sysRoleRequest 请求信息
//     * @author GD
//     * @since 2020/11/5 下午4:12
//     */
//    private SysRole querySysRole(SysRoleVo sysRoleVo) {
//
//        // 从缓存中获取角色信息
//        String key = String.valueOf(sysRoleRequest.getRoleId());
//        SysRole sysRoleCache = roleInfoCacheApi.get(key);
//        if (sysRoleCache != null) {
//            return sysRoleCache;
//        }
//
//        SysRoleEntity sysRoleEntity = this.getById(sysRoleRequest.getRoleId());
//        if (ObjectUtil.isNull(sysRole)) {
//            throw new SystemModularException(SysRoleExceptionEnum.ROLE_NOT_EXIST);
//        }
//
//        // 加入缓存
//        roleInfoCacheApi.put(key, sysRole);
//
//        return sysRole;
//    }

    /**
     * 创建查询wrapper
     *
     * @author GD
     * @since 2020/11/22 15:14
     */
    private LambdaQueryWrapper<SysRoleEntity> createWrapper(SysRoleReq req) {
        LambdaQueryWrapper<SysRoleEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(SysRoleEntity::getDelFlag, YesOrNotEnum.N.getCode())
                .orderByAsc(SysRoleEntity::getRoleSort);

        if (ObjectUtil.isEmpty(req)) {
            return wrapper;
        }
        wrapper.like(ObjectUtil.isNotEmpty(req.getRoleName()), SysRoleEntity::getRoleName, req.getRoleName())
                .like(ObjectUtil.isNotEmpty(req.getRoleCode()), SysRoleEntity::getRoleCode, req.getRoleCode())
                .eq(ObjectUtil.isNotEmpty(req.getAdminFlag()), SysRoleEntity::getAdminFlag, req.getAdminFlag());
        return wrapper;
    }

}
